const express = require('express');
const fs = require('fs-extra');
const path = require('path');
const { parse } = require('csv-parse/sync');
const { stringify } = require('csv-stringify/sync');
const { spawn } = require('child_process');

const router = express.Router();

// 保存问卷结果到CSV文件
router.post('/saveQuestionnaireResult', async (req, res) => {
  try {
    const { name, class: className, multipleChoiceScore, trueFalseScore, totalScore, wrongQuestions, grade } = req.body;

    // 验证数据
    if (!name || !className) {
      return res.status(400).json({ error: '姓名和班级不能为空' });
    }

    // CSV文件路径
    const csvFilePath = path.join(__dirname, '../public/data/wenjuan/LawQuestion.csv');

    // 确保目录存在
    const dirPath = path.dirname(csvFilePath);
    await fs.ensureDir(dirPath);
    console.log(`确保目录存在: ${dirPath}`);

    // 读取现有CSV文件
    let csvData = [];
    try {
      const exists = await fs.pathExists(csvFilePath);

      if (exists) {
        const fileContent = await fs.readFile(csvFilePath, 'utf8');
        console.log(`读取文件: ${csvFilePath}`);

        // 如果文件为空，创建空数组
        if (fileContent.trim() === '') {
          console.log('文件为空，创建空数组');
          csvData = [];
        } else {
          // 解析CSV数据
          csvData = parse(fileContent, { columns: true, skip_empty_lines: true });
          console.log(`解析到 ${csvData.length} 条记录`);
        }
      } else {
        // 如果文件不存在，创建带有标题行的新文件
        console.log(`文件不存在，将创建新文件: ${csvFilePath}`);
        csvData = [];
      }
    } catch (err) {
      console.error('读取或解析CSV文件出错:', err);
      // 如果读取或解析出错，创建空数组
      csvData = [];
    }

    // 添加新记录
    csvData.push({
      '填写人姓名': name,
      '填写人班级': className,
      '选择题成绩': multipleChoiceScore,
      '判断题成绩': trueFalseScore,
      '问卷总成绩': totalScore,
      '出错题目': wrongQuestions,
      '总体评分': grade
    });

    // 将数据写回CSV文件
    try {
      const csvString = stringify(csvData, {
        header: true,
        columns: ['填写人姓名', '填写人班级', '选择题成绩', '判断题成绩', '问卷总成绩', '出错题目', '总体评分']
      });

      await fs.writeFile(csvFilePath, csvString);
      console.log(`成功写入数据到文件: ${csvFilePath}`);
    } catch (err) {
      console.error('写入CSV文件出错:', err);
      throw new Error('无法写入数据到CSV文件');
    }

    res.status(200).json({ success: true, message: '问卷结果已保存' });
  } catch (error) {
    console.error('保存问卷结果出错:', error);
    res.status(500).json({ error: '服务器错误，无法保存问卷结果' });
  }
});

// 问卷文件上传API
router.post('/questionnaire/upload', async (req, res) => {
  try {
    const { fileName, content, directory, autoProcess } = req.body;

    // 验证数据
    if (!fileName || !content) {
      return res.status(400).json({
        success: false,
        error: '文件名和内容不能为空'
      });
    }

    // 构建文件路径
    const targetDir = directory || 'public/data/liangbiao/UnprocessedData';
    const fullPath = path.join(__dirname, '..', targetDir);
    const filePath = path.join(fullPath, fileName);

    // 确保目录存在
    await fs.ensureDir(fullPath);
    console.log(`确保目录存在: ${fullPath}`);

    // 写入文件，确保使用UTF-8编码
    await fs.writeFile(filePath, content, 'utf8');
    console.log(`成功保存文件: ${filePath}`);

    let processResult = null;

    // 如果需要自动处理，调用Python脚本
    if (autoProcess) {
      try {
        processResult = await processQuestionnaireFile(filePath, fileName);
      } catch (processError) {
        console.error('自动处理文件失败:', processError);
        // 即使处理失败，文件上传仍然成功
      }
    }

    res.status(200).json({
      success: true,
      message: '文件上传成功',
      filePath: filePath,
      processResult: processResult
    });
  } catch (error) {
    console.error('文件上传失败:', error);
    res.status(500).json({
      success: false,
      error: '服务器错误，无法保存文件'
    });
  }
});

// 获取问卷文件列表
router.get('/questionnaire/files', async (req, res) => {
  try {
    const targetDir = path.join(__dirname, '../public/data/liangbiao/UnprocessedData');

    // 确保目录存在
    await fs.ensureDir(targetDir);

    // 读取目录中的文件
    const files = await fs.readdir(targetDir);
    const csvFiles = files.filter(file => file.endsWith('.csv'));

    // 获取文件详细信息
    const fileDetails = await Promise.all(
      csvFiles.map(async (file) => {
        const filePath = path.join(targetDir, file);
        const stats = await fs.stat(filePath);
        return {
          name: file,
          size: stats.size,
          created: stats.birthtime,
          modified: stats.mtime
        };
      })
    );

    res.status(200).json({
      success: true,
      files: fileDetails
    });
  } catch (error) {
    console.error('获取文件列表失败:', error);
    res.status(500).json({
      success: false,
      error: '无法获取文件列表'
    });
  }
});

// 获取下一个问卷编号
router.get('/questionnaire/next-number', async (req, res) => {
  try {
    const targetDir = path.join(__dirname, '../public/data/liangbiao/UnprocessedData');

    // 确保目录存在
    await fs.ensureDir(targetDir);

    // 读取目录中的文件
    const files = await fs.readdir(targetDir);
    const wenjuanFiles = files.filter(file =>
      file.startsWith('wenjuan') && file.endsWith('.csv')
    );

    // 提取编号并找到最大值
    let maxNumber = 0;
    wenjuanFiles.forEach(file => {
      const match = file.match(/wenjuan(\d+)\.csv/);
      if (match) {
        const number = parseInt(match[1]);
        if (number > maxNumber) {
          maxNumber = number;
        }
      }
    });

    const nextNumber = maxNumber + 1;

    res.status(200).json({
      success: true,
      nextNumber: nextNumber
    });
  } catch (error) {
    console.error('获取下一个问卷编号失败:', error);
    res.status(500).json({
      success: false,
      error: '无法获取下一个问卷编号',
      nextNumber: 1
    });
  }
});

// 处理问卷文件的函数
async function processQuestionnaireFile(inputFilePath, originalFileName) {
  return new Promise((resolve, reject) => {
    try {
      // 生成输出文件名
      const baseName = path.basename(originalFileName, path.extname(originalFileName));
      const timestamp = Date.now();
      const outputFileName = `top30_risk_${baseName}_${timestamp}.csv`;

      // 输出目录
      const outputDir = path.join(__dirname, '../public/data/liangbiao/okData');
      const outputFilePath = path.join(outputDir, outputFileName);

      // Python脚本路径
      const pythonScript = path.join(__dirname, '../public/liangbiaocode/process_questionnaire.py');

      console.log(`开始处理文件: ${inputFilePath}`);
      console.log(`输出文件: ${outputFilePath}`);
      console.log(`Python脚本: ${pythonScript}`);

      // 调用Python脚本
      const pythonProcess = spawn('python', [pythonScript, inputFilePath, outputFilePath], {
        cwd: path.join(__dirname, '../public/liangbiaocode')
      });

      let stdout = '';
      let stderr = '';

      pythonProcess.stdout.on('data', (data) => {
        stdout += data.toString();
        console.log(`Python输出: ${data}`);
      });

      pythonProcess.stderr.on('data', (data) => {
        stderr += data.toString();
        console.error(`Python错误: ${data}`);
      });

      pythonProcess.on('close', (code) => {
        if (code === 0) {
          console.log('Python脚本执行成功');
          resolve({
            success: true,
            outputFile: outputFileName,
            outputPath: outputFilePath,
            message: '文件处理成功',
            details: stdout
          });
        } else {
          console.error(`Python脚本执行失败，退出码: ${code}`);
          reject(new Error(`Python脚本执行失败: ${stderr || '未知错误'}`));
        }
      });

      pythonProcess.on('error', (error) => {
        console.error('启动Python进程失败:', error);
        reject(new Error(`无法启动Python进程: ${error.message}`));
      });

    } catch (error) {
      console.error('处理文件时发生错误:', error);
      reject(error);
    }
  });
}

// 手动处理文件API
router.post('/questionnaire/process', async (req, res) => {
  try {
    const { fileName } = req.body;

    if (!fileName) {
      return res.status(400).json({
        success: false,
        error: '文件名不能为空'
      });
    }

    // 构建输入文件路径
    const inputDir = path.join(__dirname, '../public/data/liangbiao/UnprocessedData');
    const inputFilePath = path.join(inputDir, fileName);

    // 检查文件是否存在
    const exists = await fs.pathExists(inputFilePath);
    if (!exists) {
      return res.status(404).json({
        success: false,
        error: '指定的文件不存在'
      });
    }

    // 处理文件
    const result = await processQuestionnaireFile(inputFilePath, fileName);

    res.status(200).json({
      success: true,
      message: '文件处理成功',
      result: result
    });

  } catch (error) {
    console.error('处理文件失败:', error);
    res.status(500).json({
      success: false,
      error: `文件处理失败: ${error.message}`
    });
  }
});

// 获取已处理文件列表API
router.get('/questionnaire/processed-files', async (req, res) => {
  try {
    const outputDir = path.join(__dirname, '../public/data/liangbiao/okData');

    // 确保目录存在
    await fs.ensureDir(outputDir);

    // 读取目录中的文件
    const files = await fs.readdir(outputDir);
    const csvFiles = files.filter(file => file.endsWith('.csv'));

    // 获取文件详细信息
    const fileDetails = await Promise.all(
      csvFiles.map(async (file) => {
        const filePath = path.join(outputDir, file);
        const stats = await fs.stat(filePath);
        return {
          name: file,
          size: stats.size,
          created: stats.birthtime,
          modified: stats.mtime
        };
      })
    );

    res.status(200).json({
      success: true,
      files: fileDetails
    });
  } catch (error) {
    console.error('获取已处理文件列表失败:', error);
    res.status(500).json({
      success: false,
      error: '无法获取已处理文件列表'
    });
  }
});

module.exports = router;
